"""
备牙数据学习曲线分析工具 - 简化GUI版本
Simplified Visual Learning Curve Analyzer

此版本专注于基本功能，减少外部依赖
"""

import tkinter as tk
from tkinter import ttk, filedialog, messagebox, scrolledtext
import os
import sys
import subprocess
import threading
from datetime import datetime
import json

class SimpleAnalyzerGUI:
    """简化版分析工具GUI"""
    
    def __init__(self, root):
        self.root = root
        self.setup_window()
        self.create_interface()
        # 延迟检查依赖，确保界面已创建完成
        self.root.after(100, self.check_dependencies)
        
    def setup_window(self):
        """设置主窗口"""
        self.root.title("备牙数据学习曲线分析工具 v2.0 - 简化版")
        self.root.geometry("1000x700")
        self.root.minsize(800, 600)
        
        # 居中显示
        self.center_window()
        
        # 设置颜色主题
        self.colors = {
            'primary': '#2E86AB',
            'secondary': '#A23B72', 
            'accent': '#F18F01',
            'success': '#4CAF50',
            'error': '#F44336',
            'background': '#F5F5F5',
            'surface': '#FFFFFF',
            'text': '#212529',
            'text_light': '#6C757D'
        }
        
        self.root.configure(bg=self.colors['background'])
    
    def center_window(self):
        """窗口居中"""
        self.root.update_idletasks()
        width = 1000
        height = 700
        x = (self.root.winfo_screenwidth() // 2) - (width // 2)
        y = (self.root.winfo_screenheight() // 2) - (height // 2)
        self.root.geometry(f"{width}x{height}+{x}+{y}")
    
    def create_interface(self):
        """创建界面"""
        # 创建主标题
        self.create_header()
        
        # 创建主内容区域
        self.create_main_content()
        
        # 创建状态栏
        self.create_status_bar()
    
    def create_header(self):
        """创建头部区域"""
        header_frame = tk.Frame(self.root, bg=self.colors['primary'], height=80)
        header_frame.pack(fill='x')
        header_frame.pack_propagate(False)
        
        # 主标题
        title_label = tk.Label(header_frame,
                              text="📊 备牙数据学习曲线分析工具",
                              font=('Microsoft YaHei UI', 18, 'bold'),
                              fg='white',
                              bg=self.colors['primary'])
        title_label.pack(expand=True)
        
        # 版本信息
        version_label = tk.Label(header_frame,
                                text="Professional Data Analysis Platform v2.0",
                                font=('Microsoft YaHei UI', 10),
                                fg='#E3F2FD',
                                bg=self.colors['primary'])
        version_label.pack(side='bottom', pady=(0, 10))
    
    def create_main_content(self):
        """创建主内容区域"""
        # 主容器
        main_container = tk.Frame(self.root, bg=self.colors['background'])
        main_container.pack(fill='both', expand=True, padx=20, pady=10)
        
        # 左侧控制面板
        self.create_control_panel(main_container)
        
        # 右侧结果显示区域
        self.create_result_area(main_container)
    
    def create_control_panel(self, parent):
        """创建控制面板"""
        # 控制面板框架
        control_frame = tk.Frame(parent, bg=self.colors['surface'], width=350)
        control_frame.pack(side='left', fill='y', padx=(0, 10))
        control_frame.pack_propagate(False)
        
        # 控制面板标题
        panel_title = tk.Label(control_frame,
                              text="🔧 控制面板",
                              font=('Microsoft YaHei UI', 14, 'bold'),
                              fg=self.colors['text'],
                              bg=self.colors['surface'])
        panel_title.pack(pady=(20, 15))
        
        # 创建各个控制区域
        self.create_file_section(control_frame)
        self.create_analysis_section(control_frame)
        self.create_action_section(control_frame)
    
    def create_file_section(self, parent):
        """创建文件选择区域"""
        # 文件选择标题
        file_title = tk.Label(parent,
                             text="📁 文件管理",
                             font=('Microsoft YaHei UI', 12, 'bold'),
                             fg=self.colors['primary'],
                             bg=self.colors['surface'])
        file_title.pack(anchor='w', padx=20, pady=(0, 10))
        
        # Excel文件选择
        excel_frame = tk.LabelFrame(parent, text=" Excel数据提取 ",
                                   font=('Microsoft YaHei UI', 10, 'bold'),
                                   fg=self.colors['text'],
                                   bg=self.colors['surface'])
        excel_frame.pack(fill='x', padx=20, pady=(0, 10))
        
        # Excel文件路径
        tk.Label(excel_frame, text="Excel文件:", 
                font=('Microsoft YaHei UI', 9),
                bg=self.colors['surface']).pack(anchor='w', padx=10, pady=(10, 5))
        
        excel_path_frame = tk.Frame(excel_frame, bg=self.colors['surface'])
        excel_path_frame.pack(fill='x', padx=10, pady=(0, 5))
        
        self.excel_path_var = tk.StringVar()
        excel_entry = tk.Entry(excel_path_frame, textvariable=self.excel_path_var,
                              font=('Microsoft YaHei UI', 9))
        excel_entry.pack(side='left', fill='x', expand=True)
        
        excel_browse_btn = tk.Button(excel_path_frame, text="浏览",
                                    command=self.browse_excel_file,
                                    bg=self.colors['accent'],
                                    fg='white',
                                    relief='flat',
                                    bd=0,
                                    padx=10,
                                    font=('Microsoft YaHei UI', 9),
                                    cursor='hand2')
        excel_browse_btn.pack(side='right', padx=(5, 0))
        
        # 工作表选择
        tk.Label(excel_frame, text="工作表:", 
                font=('Microsoft YaHei UI', 9),
                bg=self.colors['surface']).pack(anchor='w', padx=10, pady=(10, 5))
        
        self.sheet_var = tk.StringVar()
        self.sheet_combo = ttk.Combobox(excel_frame, textvariable=self.sheet_var,
                                       font=('Microsoft YaHei UI', 9), state='readonly')
        self.sheet_combo.pack(fill='x', padx=10, pady=(0, 5))
        
        # 提取按钮
        extract_btn = tk.Button(excel_frame, text="🔄 提取到CSV",
                               command=self.extract_excel_data,
                               bg=self.colors['primary'],
                               fg='white',
                               relief='flat',
                               bd=0,
                               pady=8,
                               font=('Microsoft YaHei UI', 10, 'bold'),
                               cursor='hand2')
        extract_btn.pack(fill='x', padx=10, pady=10)
        
        # CSV文件选择
        csv_frame = tk.LabelFrame(parent, text=" CSV文件路径 ",
                                 font=('Microsoft YaHei UI', 10, 'bold'),
                                 fg=self.colors['text'],
                                 bg=self.colors['surface'])
        csv_frame.pack(fill='x', padx=20, pady=(0, 10))
        
        # IR组文件
        tk.Label(csv_frame, text="IR组数据文件:", 
                font=('Microsoft YaHei UI', 9),
                bg=self.colors['surface']).pack(anchor='w', padx=10, pady=(10, 5))
        
        ir_path_frame = tk.Frame(csv_frame, bg=self.colors['surface'])
        ir_path_frame.pack(fill='x', padx=10, pady=(0, 5))
        
        self.ir_path_var = tk.StringVar(value="IR组.csv")
        ir_entry = tk.Entry(ir_path_frame, textvariable=self.ir_path_var,
                           font=('Microsoft YaHei UI', 9))
        ir_entry.pack(side='left', fill='x', expand=True)
        
        ir_browse_btn = tk.Button(ir_path_frame, text="📂",
                                 command=lambda: self.browse_csv_file(self.ir_path_var),
                                 bg=self.colors['accent'],
                                 fg='white',
                                 relief='flat',
                                 bd=0,
                                 padx=8,
                                 font=('Microsoft YaHei UI', 9),
                                 cursor='hand2')
        ir_browse_btn.pack(side='right', padx=(5, 0))
        
        # MR组文件
        tk.Label(csv_frame, text="MR组数据文件:", 
                font=('Microsoft YaHei UI', 9),
                bg=self.colors['surface']).pack(anchor='w', padx=10, pady=(10, 5))
        
        mr_path_frame = tk.Frame(csv_frame, bg=self.colors['surface'])
        mr_path_frame.pack(fill='x', padx=10, pady=(0, 10))
        
        self.mr_path_var = tk.StringVar(value="MR组.csv")
        mr_entry = tk.Entry(mr_path_frame, textvariable=self.mr_path_var,
                           font=('Microsoft YaHei UI', 9))
        mr_entry.pack(side='left', fill='x', expand=True)
        
        mr_browse_btn = tk.Button(mr_path_frame, text="📂",
                                 command=lambda: self.browse_csv_file(self.mr_path_var),
                                 bg=self.colors['accent'],
                                 fg='white',
                                 relief='flat',
                                 bd=0,
                                 padx=8,
                                 font=('Microsoft YaHei UI', 9),
                                 cursor='hand2')
        mr_browse_btn.pack(side='right', padx=(5, 0))
    
    def create_analysis_section(self, parent):
        """创建分析设置区域"""
        # 分析设置标题
        analysis_title = tk.Label(parent,
                                 text="⚙️ 分析设置",
                                 font=('Microsoft YaHei UI', 12, 'bold'),
                                 fg=self.colors['primary'],
                                 bg=self.colors['surface'])
        analysis_title.pack(anchor='w', padx=20, pady=(20, 10))
        
        # 分析模式
        mode_frame = tk.LabelFrame(parent, text=" 分析模式 ",
                                  font=('Microsoft YaHei UI', 10, 'bold'),
                                  fg=self.colors['text'],
                                  bg=self.colors['surface'])
        mode_frame.pack(fill='x', padx=20, pady=(0, 10))
        
        self.analysis_mode = tk.StringVar(value="single")
        
        single_radio = tk.Radiobutton(mode_frame, text="单组预测曲线分析",
                                     variable=self.analysis_mode, value="single",
                                     font=('Microsoft YaHei UI', 10),
                                     bg=self.colors['surface'],
                                     fg=self.colors['text'])
        single_radio.pack(anchor='w', padx=10, pady=5)
        
        compare_radio = tk.Radiobutton(mode_frame, text="两组对比分析",
                                      variable=self.analysis_mode, value="compare",
                                      font=('Microsoft YaHei UI', 10),
                                      bg=self.colors['surface'],
                                      fg=self.colors['text'])
        compare_radio.pack(anchor='w', padx=10, pady=5)
        
        # 分析参数
        params_frame = tk.LabelFrame(parent, text=" 参数设置 ",
                                    font=('Microsoft YaHei UI', 10, 'bold'),
                                    fg=self.colors['text'],
                                    bg=self.colors['surface'])
        params_frame.pack(fill='x', padx=20, pady=(0, 10))
        
        # 最大训练次数
        tk.Label(params_frame, text="最大训练次数:", 
                font=('Microsoft YaHei UI', 9),
                bg=self.colors['surface']).pack(anchor='w', padx=10, pady=(10, 5))
        
        self.max_training_var = tk.IntVar(value=30)
        training_spinbox = tk.Spinbox(params_frame, from_=10, to=100,
                                     textvariable=self.max_training_var,
                                     font=('Microsoft YaHei UI', 9),
                                     width=15)
        training_spinbox.pack(anchor='w', padx=10, pady=(0, 5))
        
        # 图表标题
        tk.Label(params_frame, text="图表标题:", 
                font=('Microsoft YaHei UI', 9),
                bg=self.colors['surface']).pack(anchor='w', padx=10, pady=(10, 5))
        
        self.chart_title_var = tk.StringVar()
        title_entry = tk.Entry(params_frame, textvariable=self.chart_title_var,
                              font=('Microsoft YaHei UI', 9))
        title_entry.pack(fill='x', padx=10, pady=(0, 10))
    
    def create_action_section(self, parent):
        """创建操作按钮区域"""
        # 操作按钮标题
        action_title = tk.Label(parent,
                               text="🚀 执行操作",
                               font=('Microsoft YaHei UI', 12, 'bold'),
                               fg=self.colors['primary'],
                               bg=self.colors['surface'])
        action_title.pack(anchor='w', padx=20, pady=(20, 10))
        
        # 按钮容器
        button_container = tk.Frame(parent, bg=self.colors['surface'])
        button_container.pack(fill='x', padx=20, pady=(0, 20))
        
        # 主要操作按钮
        self.analyze_btn = tk.Button(button_container,
                                    text="📊 开始分析",
                                    command=self.run_analysis,
                                    bg=self.colors['success'],
                                    fg='white',
                                    relief='flat',
                                    bd=0,
                                    pady=12,
                                    font=('Microsoft YaHei UI', 12, 'bold'),
                                    cursor='hand2')
        self.analyze_btn.pack(fill='x', pady=(0, 10))
        
        # 进度条
        self.progress_var = tk.DoubleVar()
        self.progress_bar = ttk.Progressbar(button_container,
                                           variable=self.progress_var,
                                           mode='determinate')
        # 初始隐藏
        
        # 次要操作按钮
        button_row1 = tk.Frame(button_container, bg=self.colors['surface'])
        button_row1.pack(fill='x', pady=(0, 5))
        
        preview_btn = tk.Button(button_row1, text="👁️ 预览数据",
                               command=self.preview_data,
                               bg=self.colors['accent'],
                               fg='white',
                               relief='flat',
                               bd=0,
                               pady=8,
                               font=('Microsoft YaHei UI', 10),
                               cursor='hand2')
        preview_btn.pack(side='left', fill='x', expand=True, padx=(0, 2))
        
        help_btn = tk.Button(button_row1, text="❓ 帮助",
                            command=self.show_help,
                            bg=self.colors['accent'],
                            fg='white',
                            relief='flat',
                            bd=0,
                            pady=8,
                            font=('Microsoft YaHei UI', 10),
                            cursor='hand2')
        help_btn.pack(side='right', fill='x', expand=True, padx=(2, 0))
        
        button_row2 = tk.Frame(button_container, bg=self.colors['surface'])
        button_row2.pack(fill='x')
        
        install_btn = tk.Button(button_row2, text="📦 安装依赖",
                               command=self.install_dependencies,
                               bg=self.colors['secondary'],
                               fg='white',
                               relief='flat',
                               bd=0,
                               pady=8,
                               font=('Microsoft YaHei UI', 10),
                               cursor='hand2')
        install_btn.pack(side='left', fill='x', expand=True, padx=(0, 2))
        
        cmd_btn = tk.Button(button_row2, text="💻 命令行",
                           command=self.open_command_line,
                           bg=self.colors['secondary'],
                           fg='white',
                           relief='flat',
                           bd=0,
                           pady=8,
                           font=('Microsoft YaHei UI', 10),
                           cursor='hand2')
        cmd_btn.pack(side='right', fill='x', expand=True, padx=(2, 0))
    
    def create_result_area(self, parent):
        """创建结果显示区域"""
        # 结果区域框架
        result_frame = tk.Frame(parent, bg=self.colors['surface'])
        result_frame.pack(side='right', fill='both', expand=True)
        
        # 结果区域标题
        result_title = tk.Label(result_frame,
                               text="📋 运行结果",
                               font=('Microsoft YaHei UI', 14, 'bold'),
                               fg=self.colors['text'],
                               bg=self.colors['surface'])
        result_title.pack(pady=(20, 15))
        
        # 创建标签页
        self.notebook = ttk.Notebook(result_frame)
        self.notebook.pack(fill='both', expand=True, padx=20, pady=(0, 20))
        
        # 输出日志标签页
        self.create_log_tab()
        
        # 文件管理标签页
        self.create_files_tab()
    
    def create_log_tab(self):
        """创建日志标签页"""
        log_frame = ttk.Frame(self.notebook)
        self.notebook.add(log_frame, text="📄 运行日志")
        
        # 日志文本区域
        log_container = tk.Frame(log_frame, bg='white')
        log_container.pack(fill='both', expand=True, padx=10, pady=10)
        
        # 工具栏
        log_toolbar = tk.Frame(log_container, bg='#F0F0F0', height=35)
        log_toolbar.pack(fill='x')
        log_toolbar.pack_propagate(False)
        
        clear_log_btn = tk.Button(log_toolbar, text="🗑️ 清空日志",
                                 command=self.clear_log,
                                 bg=self.colors['error'],
                                 fg='white',
                                 relief='flat',
                                 bd=0,
                                 padx=10,
                                 font=('Microsoft YaHei UI', 9),
                                 cursor='hand2')
        clear_log_btn.pack(side='right', padx=5, pady=5)
        
        # 日志文本框
        self.log_text = scrolledtext.ScrolledText(log_container,
                                                 font=('Consolas', 10),
                                                 bg='white',
                                                 fg='black',
                                                 wrap='word',
                                                 state='disabled')
        self.log_text.pack(fill='both', expand=True)
        
        # 延迟显示初始日志，确保所有组件都已初始化
        self.root.after(50, self.init_log_messages)
    
    def create_files_tab(self):
        """创建文件管理标签页"""
        files_frame = ttk.Frame(self.notebook)
        self.notebook.add(files_frame, text="📁 文件管理")
        
        # 文件列表
        files_container = tk.Frame(files_frame, bg='white')
        files_container.pack(fill='both', expand=True, padx=10, pady=10)
        
        # 工具栏
        files_toolbar = tk.Frame(files_container, bg='#F0F0F0', height=35)
        files_toolbar.pack(fill='x')
        files_toolbar.pack_propagate(False)
        
        refresh_btn = tk.Button(files_toolbar, text="🔄 刷新",
                               command=self.refresh_files,
                               bg=self.colors['primary'],
                               fg='white',
                               relief='flat',
                               bd=0,
                               padx=10,
                               font=('Microsoft YaHei UI', 9),
                               cursor='hand2')
        refresh_btn.pack(side='left', padx=5, pady=5)
        
        open_folder_btn = tk.Button(files_toolbar, text="📂 打开文件夹",
                                   command=self.open_current_folder,
                                   bg=self.colors['accent'],
                                   fg='white',
                                   relief='flat',
                                   bd=0,
                                   padx=10,
                                   font=('Microsoft YaHei UI', 9),
                                   cursor='hand2')
        open_folder_btn.pack(side='right', padx=5, pady=5)
        
        # 文件列表
        self.files_listbox = tk.Listbox(files_container,
                                       font=('Microsoft YaHei UI', 10),
                                       bg='white',
                                       selectmode='single')
        self.files_listbox.pack(fill='both', expand=True)
        
        # 绑定双击事件
        self.files_listbox.bind('<Double-1>', self.open_selected_file)
        
        # 初始刷新
        self.refresh_files()
    
    def create_status_bar(self):
        """创建状态栏"""
        status_frame = tk.Frame(self.root, bg=self.colors['primary'], height=30)
        status_frame.pack(fill='x', side='bottom')
        status_frame.pack_propagate(False)
        
        self.status_var = tk.StringVar(value="就绪")
        status_label = tk.Label(status_frame,
                               textvariable=self.status_var,
                               font=('Microsoft YaHei UI', 9),
                               fg='white',
                               bg=self.colors['primary'])
        status_label.pack(side='left', padx=15, pady=5)
        
        # 依赖状态指示
        self.dep_status_var = tk.StringVar(value="检查中...")
        dep_status_label = tk.Label(status_frame,
                                   textvariable=self.dep_status_var,
                                   font=('Microsoft YaHei UI', 9),
                                   fg='white',
                                   bg=self.colors['primary'])
        dep_status_label.pack(side='right', padx=15, pady=5)
        
        # 时间显示
        self.time_var = tk.StringVar()
        time_label = tk.Label(status_frame,
                             textvariable=self.time_var,
                             font=('Microsoft YaHei UI', 9),
                             fg='white',
                             bg=self.colors['primary'])
        time_label.pack(side='right', padx=(0, 20), pady=5)
        
        self.update_time()
    
    def update_time(self):
        """更新时间"""
        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        if hasattr(self, 'time_var'):
            self.time_var.set(current_time)
        self.root.after(1000, self.update_time)
    
    def init_log_messages(self):
        """初始化日志消息"""
        self.log_message("=" * 60)
        self.log_message("备牙数据学习曲线分析工具 v2.0")
        self.log_message("欢迎使用！请按照以下步骤操作：")
        self.log_message("1. 选择Excel文件或CSV数据文件")
        self.log_message("2. 配置分析参数")
        self.log_message("3. 点击'开始分析'按钮")
        self.log_message("=" * 60)
    
    def update_status(self, message):
        """更新状态"""
        if hasattr(self, 'status_var'):
            self.status_var.set(message)
            self.root.update_idletasks()
    
    def log_message(self, message):
        """记录日志消息"""
        timestamp = datetime.now().strftime("%H:%M:%S")
        log_entry = f"[{timestamp}] {message}\n"
        
        if hasattr(self, 'log_text'):
            self.log_text.config(state='normal')
            self.log_text.insert('end', log_entry)
            self.log_text.see('end')
            self.log_text.config(state='disabled')
        
        # 同时更新状态栏（如果存在）
        self.update_status(message)
    
    def check_dependencies(self):
        """检查依赖"""
        def check():
            try:
                # 检查主要依赖
                import numpy
                import matplotlib
                import pandas
                
                # 检查模块文件
                if os.path.exists('curve_calc_all.py') and os.path.exists('extractor.py'):
                    if hasattr(self, 'dep_status_var'):
                        self.dep_status_var.set("✅ 依赖完整")
                    self.log_message("✅ 所有依赖检查通过")
                else:
                    if hasattr(self, 'dep_status_var'):
                        self.dep_status_var.set("⚠️ 缺少模块")
                    self.log_message("⚠️ 缺少分析模块文件")
            except ImportError as e:
                if hasattr(self, 'dep_status_var'):
                    self.dep_status_var.set("❌ 依赖缺失")
                self.log_message(f"❌ 依赖检查失败: {e}")
                self.log_message("💡 请点击'安装依赖'按钮安装所需包")
        
        # 在后台线程中检查
        threading.Thread(target=check, daemon=True).start()
    
    def browse_excel_file(self):
        """浏览Excel文件"""
        file_path = filedialog.askopenfilename(
            title="选择Excel文件",
            filetypes=[("Excel files", "*.xlsx *.xls"), ("All files", "*.*")]
        )
        if file_path:
            self.excel_path_var.set(file_path)
            self.log_message(f"已选择Excel文件: {os.path.basename(file_path)}")
            self.load_excel_sheets()
    
    def browse_csv_file(self, var):
        """浏览CSV文件"""
        file_path = filedialog.askopenfilename(
            title="选择CSV文件",
            filetypes=[("CSV files", "*.csv"), ("All files", "*.*")]
        )
        if file_path:
            var.set(file_path)
            self.log_message(f"已选择CSV文件: {os.path.basename(file_path)}")
    
    def load_excel_sheets(self):
        """加载Excel工作表"""
        excel_path = self.excel_path_var.get()
        if not excel_path or not os.path.exists(excel_path):
            return
        
        try:
            import pandas as pd
            self.log_message("正在读取Excel工作表...")
            sheets = pd.read_excel(excel_path, sheet_name=None)
            sheet_names = list(sheets.keys())
            self.sheet_combo['values'] = sheet_names
            if sheet_names:
                self.sheet_combo.set(sheet_names[0])
            self.log_message(f"成功加载 {len(sheet_names)} 个工作表")
        except ImportError:
            self.log_message("❌ 无法导入pandas，请先安装依赖")
        except Exception as e:
            self.log_message(f"❌ 读取Excel失败: {str(e)}")
    
    def extract_excel_data(self):
        """提取Excel数据"""
        excel_path = self.excel_path_var.get()
        sheet_name = self.sheet_var.get()
        
        if not excel_path or not os.path.exists(excel_path):
            messagebox.showerror("错误", "请先选择有效的Excel文件")
            return
        
        if not sheet_name:
            messagebox.showerror("错误", "请选择工作表")
            return
        
        try:
            from extractor import extract_groups_to_csv
            self.log_message("正在提取Excel数据...")
            output_csv = f"{sheet_name}.csv"
            extract_groups_to_csv(excel_path, sheet_name, output_csv)
            
            self.log_message(f"✅ 数据提取成功: {output_csv}")
            
            # 自动设置文件路径
            if "IR" in sheet_name.upper():
                self.ir_path_var.set(output_csv)
                self.log_message(f"已自动设置IR组文件: {output_csv}")
            elif "MR" in sheet_name.upper():
                self.mr_path_var.set(output_csv)
                self.log_message(f"已自动设置MR组文件: {output_csv}")
            
            # 刷新文件列表
            self.refresh_files()
            
        except ImportError:
            self.log_message("❌ 无法导入提取模块，请检查extractor.py文件")
        except Exception as e:
            self.log_message(f"❌ 数据提取失败: {str(e)}")
    
    def preview_data(self):
        """预览数据"""
        self.log_message("正在预览数据文件...")
        
        ir_path = self.ir_path_var.get()
        mr_path = self.mr_path_var.get()
        
        preview_info = "📋 数据文件预览\\n\\n"
        
        # 检查IR组文件
        if ir_path:
            if os.path.exists(ir_path):
                try:
                    with open(ir_path, 'r', encoding='utf-8') as f:
                        lines = f.readlines()[:5]  # 读取前5行
                    preview_info += f"IR组文件 ({ir_path}):\\n"
                    preview_info += f"文件大小: {os.path.getsize(ir_path)} 字节\\n"
                    preview_info += f"数据行数: {len(open(ir_path, 'r', encoding='utf-8').readlines())}\\n"
                    preview_info += "前5行预览:\\n"
                    for i, line in enumerate(lines, 1):
                        preview_info += f"  {i}: {line.strip()}\\n"
                    preview_info += "\\n"
                except Exception as e:
                    preview_info += f"IR组文件读取失败: {e}\\n\\n"
            else:
                preview_info += f"❌ IR组文件不存在: {ir_path}\\n\\n"
        
        # 检查MR组文件
        if mr_path:
            if os.path.exists(mr_path):
                try:
                    with open(mr_path, 'r', encoding='utf-8') as f:
                        lines = f.readlines()[:5]
                    preview_info += f"MR组文件 ({mr_path}):\\n"
                    preview_info += f"文件大小: {os.path.getsize(mr_path)} 字节\\n"
                    preview_info += f"数据行数: {len(open(mr_path, 'r', encoding='utf-8').readlines())}\\n"
                    preview_info += "前5行预览:\\n"
                    for i, line in enumerate(lines, 1):
                        preview_info += f"  {i}: {line.strip()}\\n"
                except Exception as e:
                    preview_info += f"MR组文件读取失败: {e}\\n"
            else:
                preview_info += f"❌ MR组文件不存在: {mr_path}\\n"
        
        messagebox.showinfo("数据预览", preview_info)
        self.log_message("数据预览完成")
    
    def run_analysis(self):
        """运行分析"""
        # 检查文件
        mode = self.analysis_mode.get()
        
        if mode == "single":
            # 单组分析，检查IR组文件
            ir_path = self.ir_path_var.get()
            if not ir_path or not os.path.exists(ir_path):
                messagebox.showerror("错误", "请先选择有效的IR组数据文件")
                return
        else:
            # 对比分析，检查两个文件
            ir_path = self.ir_path_var.get()
            mr_path = self.mr_path_var.get()
            if not ir_path or not os.path.exists(ir_path):
                messagebox.showerror("错误", "请先选择有效的IR组数据文件")
                return
            if not mr_path or not os.path.exists(mr_path):
                messagebox.showerror("错误", "请先选择有效的MR组数据文件")
                return
        
        # 禁用按钮并显示进度条
        self.analyze_btn.config(state='disabled')
        self.progress_bar.pack(fill='x', pady=5)
        self.progress_var.set(0)
        
        # 在新线程中运行分析
        threading.Thread(target=self._run_analysis_thread, daemon=True).start()
    
    def _run_analysis_thread(self):
        """分析线程"""
        try:
            mode = self.analysis_mode.get()
            max_training = self.max_training_var.get()
            title = self.chart_title_var.get()
            
            self.root.after(0, lambda: self.log_message("🚀 开始数据分析..."))
            self.root.after(0, lambda: self.progress_var.set(10))
            
            # 构建命令行参数
            cmd = ["python", "curve_calc_all.py"]
            cmd.extend(["--mode", mode])
            cmd.extend(["--max_training", str(max_training)])
            
            if mode == "single":
                ir_path = self.ir_path_var.get()
                cmd.extend(["--single_file", ir_path])
            else:
                ir_path = self.ir_path_var.get()
                mr_path = self.mr_path_var.get()
                cmd.extend(["--ir_file", ir_path])
                cmd.extend(["--mr_file", mr_path])
            
            if title:
                cmd.extend(["--title", title])
            
            self.root.after(0, lambda: self.progress_var.set(30))
            self.root.after(0, lambda: self.log_message(f"执行命令: {' '.join(cmd)}"))
            
            # 执行分析命令
            result = subprocess.run(cmd, capture_output=True, text=True, encoding='utf-8')
            
            self.root.after(0, lambda: self.progress_var.set(80))
            
            if result.returncode == 0:
                self.root.after(0, lambda: self.log_message("✅ 分析完成！"))
                self.root.after(0, lambda: self.log_message("输出信息:"))
                
                # 显示输出信息
                if result.stdout:
                    for line in result.stdout.split('\\n'):
                        if line.strip():
                            self.root.after(0, lambda l=line: self.log_message(f"  {l}"))
                
                self.root.after(0, lambda: self.progress_var.set(100))
                self.root.after(0, lambda: messagebox.showinfo("完成", "数据分析完成！\\n\\n结果文件已保存到当前目录。"))
                
                # 刷新文件列表
                self.root.after(0, self.refresh_files)
                
            else:
                self.root.after(0, lambda: self.log_message("❌ 分析失败！"))
                self.root.after(0, lambda: self.log_message("错误信息:"))
                
                if result.stderr:
                    for line in result.stderr.split('\\n'):
                        if line.strip():
                            self.root.after(0, lambda l=line: self.log_message(f"  {l}"))
                
                self.root.after(0, lambda: messagebox.showerror("错误", f"分析失败：\\n{result.stderr}"))
            
        except FileNotFoundError:
            self.root.after(0, lambda: self.log_message("❌ 无法找到Python或分析模块"))
            self.root.after(0, lambda: messagebox.showerror("错误", "无法找到Python或分析模块文件"))
        except Exception as e:
            self.root.after(0, lambda: self.log_message(f"❌ 分析异常: {str(e)}"))
            self.root.after(0, lambda: messagebox.showerror("错误", f"分析异常：{str(e)}"))
        finally:
            # 重新启用按钮并隐藏进度条
            self.root.after(0, lambda: self.analyze_btn.config(state='normal'))
            self.root.after(0, lambda: self.progress_bar.pack_forget())
    
    def install_dependencies(self):
        """安装依赖"""
        self.log_message("🔧 开始安装依赖包...")
        
        def install():
            try:
                if os.name == 'nt':  # Windows
                    if os.path.exists('install_dependencies.bat'):
                        result = subprocess.run(['install_dependencies.bat'], 
                                               capture_output=True, text=True, shell=True)
                    else:
                        result = subprocess.run(['pip', 'install', '-r', 'requirements.txt'], 
                                               capture_output=True, text=True)
                else:  # Unix/Linux/Mac
                    if os.path.exists('install_dependencies.sh'):
                        result = subprocess.run(['bash', 'install_dependencies.sh'], 
                                               capture_output=True, text=True)
                    else:
                        result = subprocess.run(['pip3', 'install', '-r', 'requirements.txt'], 
                                               capture_output=True, text=True)
                
                if result.returncode == 0:
                    self.root.after(0, lambda: self.log_message("✅ 依赖安装成功！"))
                    self.root.after(0, lambda: messagebox.showinfo("成功", "依赖包安装完成！\\n\\n请重新检查依赖状态。"))
                else:
                    self.root.after(0, lambda: self.log_message(f"❌ 依赖安装失败: {result.stderr}"))
                    self.root.after(0, lambda: messagebox.showerror("失败", f"依赖安装失败：\\n{result.stderr}"))
                
                # 重新检查依赖
                self.root.after(0, self.check_dependencies)
                
            except Exception as e:
                self.root.after(0, lambda: self.log_message(f"❌ 安装异常: {str(e)}"))
                self.root.after(0, lambda: messagebox.showerror("错误", f"安装异常：{str(e)}"))
        
        # 在后台线程中安装
        threading.Thread(target=install, daemon=True).start()
    
    def open_command_line(self):
        """打开命令行"""
        self.log_message("💻 正在打开命令行...")
        try:
            if os.name == 'nt':  # Windows
                subprocess.Popen(['cmd'], shell=True)
            else:  # Unix/Linux/Mac
                subprocess.Popen(['gnome-terminal'], shell=False)
            self.log_message("✅ 命令行已打开")
        except Exception as e:
            self.log_message(f"❌ 无法打开命令行: {str(e)}")
    
    def show_help(self):
        """显示帮助"""
        help_text = """
🔧 备牙数据学习曲线分析工具 - 使用指南

📋 基本功能：
• Excel数据提取：从Excel文件中提取学习曲线数据
• 单组预测分析：为单个数据组生成学习曲线预测  
• 两组对比分析：比较IR组和MR组的学习曲线差异

🚀 使用步骤：
1. 准备数据文件
   - 可以使用Excel源文件 + 工作表提取
   - 或直接指定CSV数据文件

2. 选择分析模式
   - 单组预测：分析单个组的学习曲线
   - 两组对比：比较IR组和MR组的差异

3. 配置参数
   - 最大训练次数：预测的训练次数范围
   - 图表标题：自定义图表标题

4. 执行分析
   - 点击"开始分析"按钮
   - 查看运行日志了解进度
   - 分析完成后查看生成的文件

📊 输出文件：
• PNG图片：可视化图表
• CSV文件：详细的预测数据

💡 提示：
• 首次使用请先点击"安装依赖"
• 支持中文文件名和路径
• 可在文件管理标签页查看生成的文件
• 双击文件列表中的文件可以打开查看

❓ 故障排除：
• 如果分析失败，请检查数据文件格式
• 确保已安装所有必需的依赖包
• 查看运行日志获取详细错误信息
        """
        
        help_window = tk.Toplevel(self.root)
        help_window.title("使用帮助")
        help_window.geometry("600x500")
        help_window.resizable(False, False)
        
        # 居中显示
        help_window.transient(self.root)
        help_window.grab_set()
        
        x = self.root.winfo_x() + (self.root.winfo_width() // 2) - 300
        y = self.root.winfo_y() + (self.root.winfo_height() // 2) - 250
        help_window.geometry(f"600x500+{x}+{y}")
        
        help_label = tk.Label(help_window,
                             text=help_text,
                             font=('Microsoft YaHei UI', 10),
                             justify='left',
                             bg='white',
                             fg='black')
        help_label.pack(fill='both', expand=True, padx=20, pady=20)
        
        # 关闭按钮
        close_btn = tk.Button(help_window,
                             text="关闭",
                             command=help_window.destroy,
                             bg=self.colors['primary'],
                             fg='white',
                             relief='flat',
                             bd=0,
                             pady=8,
                             font=('Microsoft YaHei UI', 10),
                             cursor='hand2')
        close_btn.pack(pady=(0, 20))
    
    def clear_log(self):
        """清空日志"""
        self.log_text.config(state='normal')
        self.log_text.delete('1.0', 'end')
        self.log_text.config(state='disabled')
        self.log_message("日志已清空")
    
    def refresh_files(self):
        """刷新文件列表"""
        self.files_listbox.delete(0, 'end')
        
        try:
            # 获取当前目录下的相关文件
            current_dir = os.getcwd()
            files = []
            
            for file in os.listdir(current_dir):
                if file.endswith(('.csv', '.png', '.xlsx', '.xls')):
                    file_size = os.path.getsize(file)
                    file_time = datetime.fromtimestamp(os.path.getmtime(file)).strftime("%Y-%m-%d %H:%M")
                    files.append((file, file_size, file_time))
            
            # 按修改时间排序
            files.sort(key=lambda x: x[2], reverse=True)
            
            for file, size, time in files:
                size_str = f"{size:,} 字节" if size < 1024 else f"{size//1024:,} KB"
                display_text = f"{file:<30} {size_str:<15} {time}"
                self.files_listbox.insert('end', display_text)
            
            if not files:
                self.files_listbox.insert('end', "没有找到相关文件")
            
        except Exception as e:
            self.files_listbox.insert('end', f"刷新失败: {str(e)}")
    
    def open_current_folder(self):
        """打开当前文件夹"""
        try:
            if os.name == 'nt':  # Windows
                os.startfile(os.getcwd())
            elif os.name == 'posix':  # Linux/Mac
                subprocess.run(['xdg-open', os.getcwd()])
            self.log_message("📂 已打开文件夹")
        except Exception as e:
            self.log_message(f"❌ 无法打开文件夹: {str(e)}")
    
    def open_selected_file(self, event):
        """打开选中的文件"""
        selection = self.files_listbox.curselection()
        if selection:
            file_info = self.files_listbox.get(selection[0])
            filename = file_info.split()[0]  # 提取文件名
            
            if os.path.exists(filename):
                try:
                    if os.name == 'nt':  # Windows
                        os.startfile(filename)
                    elif os.name == 'posix':  # Linux/Mac
                        subprocess.run(['xdg-open', filename])
                    self.log_message(f"📄 已打开文件: {filename}")
                except Exception as e:
                    self.log_message(f"❌ 无法打开文件: {str(e)}")


def main():
    """主函数"""
    # 检查Python版本
    if sys.version_info < (3, 7):
        messagebox.showerror("版本错误", "此程序需要Python 3.7或更高版本")
        return
    
    root = tk.Tk()
    
    # 设置DPI感知（Windows）
    try:
        from ctypes import windll
        windll.shcore.SetProcessDpiAwareness(1)
    except:
        pass
    
    app = SimpleAnalyzerGUI(root)
    
    try:
        root.mainloop()
    except KeyboardInterrupt:
        print("\\n程序被用户中断")
    except Exception as e:
        messagebox.showerror("程序错误", f"程序运行出错：{str(e)}")


if __name__ == "__main__":
    main()
